#ifndef _M_UTIL_H_
#define _M_UTIL_H_
#include "logger.hpp"
#include <mysql/mysql.h>
#include <string>
#include <iostream>
#include<memory>
#include<jsoncpp/json/json.h>
#include<sstream>
#include<vector>
#include<fstream>
#include<mutex>
#include<assert.h>
#include<websocketpp/server.hpp>
#include<websocketpp/config/asio_no_tls.hpp>

typedef websocketpp::server<websocketpp::config::asio> wsserver_t;

/*MySQL的工具类封装*/

class mysql_util
{
public:
    //创建数据库的接口：这个接口包含初始化句柄、连接服务器、设置字符集和选择数据库
    /*host:主机名 username：用户名 ossword: 密码 dbname: 要使用的数据库名 port：MYSQL数据库端口号*/
    /*首先是需要创建MySQL数据库的操作句柄，然后返回*/
    /*在这个创建MySQL数据库操作句柄的函数中，可以同时设置字符集，以及连接到MySQL数据库的服务器*/
    static MYSQL* mysql_create(
        const std::string& host,
        const std::string& username,
        const std::string& password,
        const std::string& dbname,
        const uint16_t port)
    {
        //创建MySQL数据库的操作句柄
        MYSQL* mysql = mysql_init(NULL);
        if(mysql==NULL)
        {
            ELOG("mysql init failed");
            return nullptr;
        }
        //使用MySQL数据库的句柄，将其连接到MySQL服务器中,由于是C连接的MySQL操作，因此需要C语言风格的字符串
        if(mysql_real_connect(mysql,host.c_str(),username.c_str(),password.c_str(),dbname.c_str(),port,NULL,0)==NULL)
        {
            /*如果失败了，那么使用mysql_error接口，获取失败原因，并且需要释放操作句柄*/
            ELOG("connect mysql server failed :%s",mysql_error(mysql));
            mysql_close(mysql);
            return nullptr;
        }
        //使用MySQL数据库操作句柄，设置字符集
        if(mysql_set_character_set(mysql,"utf8")!=0)
        {
            ELOG("set client character failed :%s",mysql_error(mysql));
            mysql_close(mysql);
            return nullptr;
        }
        return mysql;
    }

    /*执行语句*/
    /*mysql_exec接口参数是mysql操作句柄，以及需要执行的语句的字符串*/
    static bool mysql_exec(MYSQL* mysql,const std::string& sql)
    {
        //执行语句
        int ret = mysql_query(mysql,sql.c_str());
        if(ret != 0)
        {
            /*失败的话，就将执行语句和失败原因在日志中打印出来，并且销毁句柄*/
            ELOG("%s\n",sql.c_str());
            ELOG("mysql query failed :%s\n",mysql_error(mysql));
            //mysql_close(mysql);
            return false;
        }
        return true;
    }

    /*释放句柄*/
    static bool mysql_destory(MYSQL* mysql)
    {
        if(mysql!=NULL)
        {
            mysql_close(mysql);
        }
    }
};
class json_util
{
public:
    static bool serialize(const Json::Value &root,std::string &str)
    {
        Json::StreamWriterBuilder swb;
        std::unique_ptr<Json::StreamWriter>sw(swb.newStreamWriter());
        std::stringstream ss;
        int ret = sw->write(root,&ss);
        if(ret!=0)
        {
            ELOG("Json serialize failed!");
            return false;
        }
        str = ss.str();
        return true;
    }
    static bool unserialize(const std::string &str ,Json::Value &root)
    {
        Json::CharReaderBuilder crb;
        std::unique_ptr<Json::CharReader> cr(crb.newCharReader());
        std::string err;
        bool ret = cr->parse(str.c_str(), str.c_str() + str.size(), &root,&err);
        if (ret==false) 
        {
            ELOG("UnSerialize failed!");
            return false;
        }
        return true;
    }

};

class string_util
{
public:
    static int split(const std::string& src,const std::string& sep,std::vector<std::string>& res)
    {
        size_t pos,idx = 0;
        while(idx<src.size())
        {
            pos = src.find(sep,idx);
            if(pos==std::string::npos)
            {
                res.push_back(src.substr(idx));
                break;
            }
            if(pos==idx)
            {
                idx+=sep.size();
                continue;
            }
            res.push_back(src.substr(idx,pos-idx));
            idx  = pos+sep.size();
        }
        return res.size();
    }
};

class file_util
{
public:
    static bool read(const std::string& filename,std::string& body)
    {
        //打开文件
        std::ifstream ifs(filename,std::ios::binary);
        if(ifs.is_open()==false)
        {
            ELOG("%s file open failed!",filename.c_str());
            return false;
        }
        //获取文件大小
        size_t fsize = 0;
        ifs.seekg(0,std::ios::end);//偏移量为0，跳转到文件末尾
        fsize = ifs.tellg();//获取当前读写文件相对于文件起始位置的偏移量
        ifs.seekg(0,std::ios::beg);//放回起始位置
        body.resize(fsize);
        //将文件数据读取
        ifs.read(&body[0],fsize);//不能使用body.c_str()，因为它返回的是一个const的起始地址，不能被修改
        if(ifs.good()==false)
        {
            ELOG("read %s file content failed",filename.c_str());
            ifs.close();
            return false;
        }
        //关闭文件
        ifs.close();
        return true;
    }

};
#endif